package com.base.dataStructure.array;

import java.net.IDN;
import java.util.Arrays;
import java.util.Iterator;
import java.util.function.Consumer;
import java.util.stream.IntStream;

/**
 * @Author: hdhao
 * @Create: 2023/3/26 - 16:39
 * @Version: v1.0
 */
//动态数组
public class DynamicArray implements Iterable<Integer>{
    //逻辑大小
    private int size = 0;
    //容量
    private int capacity = 8;
    //存储数据的数组
    //初始给一个空数组,当第一次添加元素的时候,初始化数组的容量为8(懒加载)
    private int[] array = {};

    /**
     * 添加元素到数组末尾
     * @param element 待添加的元素
     */
    public void addLast(int element){
//        array[size] = element;
//        size++;
        add(size,element);
    }

    /**
     * 向数组中指定位置添加一个元素
     * @param index
     * @param element
     */
    public void add(int index,int element){
        checkAndGrow();
        //添加逻辑
        if (index >=0 && index < size){
            //将index后边的数据向后移动一位
            /**
             * System.arraycopy 系统提供的数组拷贝方法,参数如下
             * Object src, 要参与拷贝的数组
             * int  srcPos, 从数组的那个下标开始拷贝
             * Object dest, 目标数组
             * int destPos, 要拷贝的元素在目标数组中的起始下标
             * int length, 要拷贝多少个元素
             */
            System.arraycopy(array,index,array,index+1,size-index);
        }
        array[index] = element;
        size++;
    }

    /**
     * 检查容量,如果容量不够就扩容
     */
    private void checkAndGrow() {
        if (size == 0){
            array = new int[capacity];
        }else if (size == capacity){
            //需要进行扩容
            capacity = capacity + capacity >> 1;
            int[] newArray = new int[capacity];
            System.arraycopy(array,0,newArray,0,size);
            array = newArray;
        }
    }

    /**
     * 根据下标位置获取数组中的元素
     * @param index 下标
     * @return 元素,下标合法时直接返回,不合法时返回-1
     */
    public int get(int index){
        //TODO 下标暂时先不检测是否合法
            return array[index];
    }

    public void foreach(Consumer<Integer> consumer){
        for (int i = 0; i < size; i++) {
            consumer.accept(array[i]);
        }
    }

    @Override
    public Iterator<Integer> iterator() {
        return new Iterator<Integer>() {
            int i = 0;
            @Override
            public boolean hasNext() {//有沒有下一个元素
                return i < size;
            }

            @Override
            public Integer next() {//返回当前元素，并移动到下一个元素
                return array[i++];
            }
        };
    }

    public IntStream stream(){
        return IntStream.of(Arrays.copyOfRange(array,0,size));
    }

    public int remove(int index){
        int removed = array[index];
        if (index < size - 1){
            System.arraycopy(array,index+1,array,index,size-index-1);
        }
        size--;
        return removed;
    }
}
